home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 June / PCWorld_2007-06_cd.bin / v cisle / tclock / tclocklight-040702-3.exe / source / player / player.c < prev    next >
C/C++ Source or Header  |  2004-05-12  |  10KB  |  434 lines
  1. /*-------------------------------------------------------------
  2.   player.c : sound player
  3.   (C) 1997-2003 Kazuto Sato
  4.   Please read readme.txt about the license.
  5.   
  6.   Written by Kazubon, Nanashi-san
  7. ---------------------------------------------------------------*/
  8.  
  9. #include "tcplayer.h"
  10.  
  11. /* Globals */
  12.  
  13. void InitPlayer(HWND hwnd);
  14. void OnTimerPlayer(HWND hwnd);
  15. BOOL Player(HWND hwnd, const char *fname);
  16. BOOL IsPlayerPlaying(void);
  17. void OnMCINotifyPlayer(HWND hwnd, WPARAM wFlags, LONG lDevID);
  18. void StopPlayer(HWND hwnd);
  19. void PausePlayer(HWND hwnd);
  20. void PrevNextPlayer(HWND hwnd, BOOL bNext);
  21.  
  22. /* Statics */
  23.  
  24. static BOOL PlayByNumber(HWND hwnd, int n);
  25. static void ClearDisp(HWND hwnd);
  26. static void ListSoundFiles(HWND hwnd, const char *src);
  27. static void GetFilesInDir(HWND hwnd, const char *root);
  28.  
  29. static BOOL m_bDisp = FALSE;
  30. static int m_nDispType = 0;
  31. static int m_nUserStr = 0;
  32. static char *m_section = "Player";
  33. static BOOL m_bPlaying = FALSE;
  34. static int m_numFiles = 0;
  35. static int m_nCurrent = 0;
  36.  
  37. /*-------------------------------------------------------------
  38.   initialize
  39. ---------------------------------------------------------------*/
  40. void InitPlayer(HWND hwnd)
  41. {
  42.     ClearDisp(hwnd);
  43.     
  44.     m_bDisp = GetMyRegLong(m_section, "Disp", FALSE);
  45.     m_nDispType = GetMyRegLong(m_section, "DispType", 1);
  46.     m_nUserStr = GetMyRegLong(m_section, "UserStr", 0);
  47. }
  48.  
  49. /*-------------------------------------------------------------
  50.   WM_TIMER message
  51. ---------------------------------------------------------------*/
  52. void OnTimerPlayer(HWND hwnd)
  53. {
  54.     char s[31], s2[31];
  55.     wchar_t ws[31];
  56.     
  57.     if(!m_bDisp || !m_bPlaying) return;
  58.     
  59.     if(GetPlayingPosition(s))  // common/playfile.c
  60.     {
  61.         if(m_numFiles > 1)
  62.         {
  63.             wsprintf(s2, "[%02d]", m_nCurrent+1);
  64.             strcat(s2, s);
  65.         }
  66.         else strcpy(s2, s);
  67.         
  68.         MultiByteToWideChar(CP_ACP, 0, s2, -1, ws, 30);
  69.         if(m_nDispType == 0)
  70.             SendStringToOtherW(g_hwndClock, hwnd, ws, COPYDATA_DISP1);
  71.         else if(m_nDispType == 1)
  72.             SendStringToOtherW(g_hwndClock, hwnd, ws, COPYDATA_CAT1);
  73.         else if(m_nDispType == 2)
  74.             SendStringToOtherW(g_hwndClock, hwnd, ws,
  75.                 COPYDATA_USTR0 + m_nUserStr);
  76.     }
  77.     else StopPlayer(hwnd);
  78. }
  79.  
  80. /*------------------------------------------------
  81.   TClock player
  82. --------------------------------------------------*/
  83. BOOL Player(HWND hwnd, const char *src)
  84. {
  85.     char fname[MAX_PATH], fname2[MAX_PATH];
  86.     
  87.     StopFile();
  88.     ClearDisp(hwnd);
  89.     
  90.     if(!src || *src == 0) return FALSE;
  91.     
  92.     ListSoundFiles(hwnd, src);
  93.     m_numFiles = SendDlgItemMessage(hwnd, IDC_LIST, LB_GETCOUNT, 0, 0);
  94.     if(m_numFiles == 0) return FALSE;
  95.     m_nCurrent = 0;
  96.     
  97.     SendDlgItemMessage(hwnd, IDC_LIST, LB_GETTEXT, m_nCurrent,
  98.         (LPARAM)fname);
  99.     
  100.     if(lstrcmpi(fname, "cdaudio") != 0)
  101.         RelToAbs(fname2, fname);
  102.     else strcpy(fname2, fname);
  103.     
  104.     m_bPlaying = PlayMCI(hwnd, fname2, 0); // common/playfile.c
  105.     
  106.     return m_bPlaying;
  107. }
  108.  
  109. /*------------------------------------------------
  110.    Playing?
  111. --------------------------------------------------*/
  112. BOOL IsPlayerPlaying(void)
  113. {
  114.     return m_bPlaying;
  115. }
  116.  
  117. /*------------------------------------------------
  118.    MM_MCINOTIFY message
  119. --------------------------------------------------*/
  120. void OnMCINotifyPlayer(HWND hwnd, WPARAM wFlags, LONG lDevID)
  121. {
  122.     if(!m_bPlaying) return;
  123.     
  124.     if(wFlags != MCI_NOTIFY_SUCCESSFUL && wFlags != MCI_NOTIFY_FAILURE)
  125.         return;
  126.     
  127.     if(wFlags == MCI_NOTIFY_SUCCESSFUL)
  128.     {
  129.         if(m_numFiles > 1)
  130.         {
  131.             m_nCurrent++;
  132.             if(m_nCurrent < m_numFiles)
  133.             {
  134.                 m_bPlaying = PlayByNumber(hwnd, m_nCurrent);
  135.                 if(m_bPlaying) return;
  136.             }
  137.         }
  138.     }
  139.     
  140.     StopPlayer(hwnd);
  141. }
  142.  
  143. /*-------------------------------------------------------------
  144.   stop playing
  145. ---------------------------------------------------------------*/
  146. void StopPlayer(HWND hwnd)
  147. {
  148.     StopFile();
  149.     ClearDisp(hwnd);
  150.     m_bPlaying = FALSE;
  151.     OnRequestMenu(hwnd, TRUE);
  152.     if(!g_hDlg)
  153.         PostMessage(hwnd, WM_CLOSE, 0, 0);
  154. }
  155.  
  156. /*-------------------------------------------------------------
  157.   pause/resume
  158. ---------------------------------------------------------------*/
  159. void PausePlayer(HWND hwnd)
  160. {
  161.     if(m_bPlaying)
  162.     {
  163.         if(!PauseResume(hwnd)) StopPlayer(hwnd);
  164.     }
  165. }
  166.  
  167. /*-------------------------------------------------------------
  168.   previous or next
  169. ---------------------------------------------------------------*/
  170. void PrevNextPlayer(HWND hwnd, BOOL bNext)
  171. {
  172.     if(!m_bPlaying) return;
  173.     
  174.     if(m_numFiles > 1)
  175.     {
  176.         if(bNext)
  177.         {
  178.             if(m_nCurrent < m_numFiles - 1)
  179.             {
  180.                 m_nCurrent++;
  181.                 m_bPlaying = PlayByNumber(hwnd, m_nCurrent);
  182.             }
  183.         }
  184.         else
  185.         {
  186.             if(0 < m_nCurrent)
  187.             {
  188.                 m_nCurrent--;
  189.                 m_bPlaying = PlayByNumber(hwnd, m_nCurrent);
  190.             }
  191.         }
  192.         if(!m_bPlaying) StopPlayer(hwnd);
  193.     }
  194.     else
  195.     {
  196.         if(!PrevNextTrack(hwnd, bNext))
  197.             StopPlayer(hwnd);
  198.     }
  199. }
  200.  
  201. /*-------------------------------------------
  202.   add item to tcmenu*.txt
  203. ---------------------------------------------*/
  204. void OnRequestMenu(HWND hwnd, BOOL bClear)
  205. {
  206.     char tcmenutxt[MAX_PATH];
  207.     WIN32_FIND_DATA fd;
  208.     HANDLE hfind;
  209.     HFILE hf;
  210.     int size;
  211.     char *buf;
  212.     const char *p, *np;
  213.     static BOOL bWrite = FALSE;
  214.     
  215.     if(!bClear && !m_bPlaying) return;
  216.     
  217.     if(bClear && !bWrite) return;
  218.     
  219.     // common/tclang.c
  220.     FindFileWithLangCode(tcmenutxt, GetUserDefaultLangID(), TCMENUTXT);
  221.     
  222.     hfind = FindFirstFile(tcmenutxt, &fd);
  223.     if(hfind == INVALID_HANDLE_VALUE) return;
  224.     
  225.     FindClose(hfind);
  226.     size = (int)fd.nFileSizeLow;
  227.     buf = malloc(size+1);
  228.     if(!buf) return;
  229.     
  230.     hf = _lopen(tcmenutxt, OF_READWRITE);
  231.     if(hf == HFILE_ERROR) { free(buf); return; }
  232.     _lread(hf, buf, size);
  233.     *(buf + size) = 0;
  234.     
  235.     _llseek(hf, 0, 0);
  236.     
  237.     p = buf;
  238.     while(*p)
  239.     {
  240.         if(strncmp(p, "#Player Begin", 13) == 0)
  241.         {
  242.             char s[160];
  243.             
  244.             np = nextline(p);
  245.             _lwrite(hf, p, np - p);
  246.             p = np;
  247.             
  248.             if(m_bPlaying)
  249.             {
  250.                 wsprintf(s, "\"%s\" post %s %d\r\n",
  251.                     MyString(IDS_STOP, "Stop"), CLASS_TCLOCKPLAYER,
  252.                     PLAYERM_STOP);
  253.                 _lwrite(hf, s, strlen(s));
  254.                 wsprintf(s, "\"%s\" post %s %d\r\n",
  255.                     MyString(IDS_PAUSE, "Pause"), CLASS_TCLOCKPLAYER,
  256.                     PLAYERM_PAUSE);
  257.                 _lwrite(hf, s, strlen(s));
  258.                 if((m_numFiles > 1 && m_nCurrent > 0) || IsPrevNext(FALSE))
  259.                 {
  260.                     wsprintf(s, "\"%s\" post %s %d\r\n",
  261.                         MyString(IDS_PREV, "Prev"), CLASS_TCLOCKPLAYER,
  262.                         PLAYERM_PREV);
  263.                     _lwrite(hf, s, strlen(s));
  264.                 }
  265.                 if((m_numFiles > 1 && m_nCurrent < m_numFiles - 1)
  266.                     || IsPrevNext(TRUE))
  267.                 {
  268.                     wsprintf(s, "\"%s\" post %s %d\r\n",
  269.                         MyString(IDS_NEXT, "Next"), CLASS_TCLOCKPLAYER,
  270.                         PLAYERM_NEXT);
  271.                     _lwrite(hf, s, strlen(s));
  272.                 }
  273.             }
  274.             
  275.             while(*p)
  276.             {
  277.                 if(strncmp(p, "#Player End", 11) == 0)
  278.                     break;
  279.                 p = nextline(p);
  280.             }
  281.         }
  282.         else
  283.         {
  284.             np = nextline(p);
  285.             _lwrite(hf, p, np - p);
  286.             p = np;
  287.         }
  288.     }
  289.     
  290.     _lwrite(hf, NULL, 0); // truncate
  291.     
  292.     _lclose(hf);
  293.     free(buf);
  294.     
  295.     bWrite = TRUE;
  296. }
  297.  
  298. /*-------------------------------------------------------------
  299.   play track
  300. ---------------------------------------------------------------*/
  301. BOOL PlayByNumber(HWND hwnd, int n)
  302. {
  303.     char fname[MAX_PATH], fname2[MAX_PATH];
  304.     
  305.     if(!(0 <= n && n < m_numFiles)) return FALSE;
  306.     
  307.     SendDlgItemMessage(hwnd, IDC_LIST,
  308.         LB_GETTEXT, m_nCurrent, (LPARAM)fname);
  309.     RelToAbs(fname2, fname);
  310.     StopFile();
  311.     return PlayMCI(hwnd, fname2, 0); // common/playfile.c
  312. }
  313.  
  314. /*-------------------------------------------------------------
  315.   clear elasped time
  316. ---------------------------------------------------------------*/
  317. void ClearDisp(HWND hwnd)
  318. {
  319.     if(m_bPlaying && m_bDisp)
  320.     {
  321.         if(m_nDispType == 0)
  322.             SendStringToOtherW(g_hwndClock, hwnd, L"", COPYDATA_DISP1);
  323.         else if(m_nDispType == 1)
  324.             SendStringToOtherW(g_hwndClock, hwnd, L"", COPYDATA_CAT1);
  325.         else if(m_nDispType == 2)
  326.             SendStringToOtherW(g_hwndClock, hwnd, L"",
  327.                 COPYDATA_USTR0 + m_nUserStr);
  328.     }
  329. }
  330.  
  331. /*-------------------------------------------------------------
  332.   make sound files list
  333. ---------------------------------------------------------------*/
  334. void ListSoundFiles(HWND hwnd, const char *src)
  335. {
  336.     const char *p = src;
  337.     char fname[MAX_PATH];
  338.     BOOL bquot;
  339.     int i;
  340.     WIN32_FIND_DATA fd;
  341.     HANDLE hfind;
  342.     BOOL bdir;
  343.     
  344.     m_numFiles = 0;
  345.     SendDlgItemMessage(hwnd, IDC_LIST, LB_RESETCONTENT, 0, 0);
  346.     
  347.     while(*p)
  348.     {
  349.         bquot = FALSE;
  350.         if(*p == '\"') { bquot = TRUE; p++; }
  351.         for(i = 0; *p && i < MAX_PATH-1; i++)
  352.         {
  353.             if(bquot)
  354.             {
  355.                 if(*p == '\"') { p++; break; }
  356.             }
  357.             else if(*p == ' ') break;
  358.             fname[i] = *p++;
  359.         }
  360.         fname[i] = 0;
  361.         
  362.         bdir = FALSE;
  363.         if((('A' <= fname[0] && fname[0] <= 'Z') ||
  364.                 ('a' <= fname[0] && fname[0] <= 'z')) &&
  365.             fname[1] == ':' && 
  366.             fname[2] == '\\' && fname[3] == 0)
  367.         {
  368.             char temp[80];
  369.             strcpy(temp, fname);
  370.             strcat(temp, "*.cda");
  371.             if(!IsFile(temp)) bdir = TRUE;
  372.         }
  373.         else
  374.         {
  375.             hfind = FindFirstFile(fname, &fd);
  376.             if(hfind != INVALID_HANDLE_VALUE)
  377.             {
  378.                 FindClose(hfind);
  379.                 if(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
  380.                     bdir = TRUE;
  381.             }
  382.         }
  383.         
  384.         if(bdir)
  385.             GetFilesInDir(hwnd, fname);
  386.         else
  387.         {
  388.             if(IsSoundFile(fname))
  389.                 SendDlgItemMessage(hwnd, IDC_LIST,
  390.                     LB_ADDSTRING, 0, (LPARAM)fname);
  391.         }
  392.         
  393.         while(*p == ' ') p++;
  394.     }
  395. }
  396.  
  397. /*-------------------------------------------------------------
  398.   search sound files in directory
  399. ---------------------------------------------------------------*/
  400. void GetFilesInDir(HWND hwnd, const char *root)
  401. {
  402.     char search[MAX_PATH], fname[MAX_PATH];
  403.     WIN32_FIND_DATA fd;
  404.     HANDLE hfind;
  405.     
  406.     strcpy(search, root);
  407.     add_title(search, "*.*");
  408.     
  409.     hfind = FindFirstFile(search, &fd);
  410.     if(hfind == INVALID_HANDLE_VALUE) return;
  411.     while(1)
  412.     {
  413.         if(fd.cFileName[0] != '.')
  414.         {
  415.             strcpy(fname, root);
  416.             add_title(fname, fd.cFileName);
  417.             
  418.             if(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
  419.                 GetFilesInDir(hwnd, fname); // recursion
  420.             else
  421.             {
  422.                 if(IsSoundFile(fname))
  423.                     SendDlgItemMessage(hwnd, IDC_LIST,
  424.                         LB_ADDSTRING, 0, (LPARAM)fname);
  425.             }
  426.         }
  427.         
  428.         if(FindNextFile(hfind, &fd) == 0) break;
  429.     }
  430.     
  431.     FindClose(hfind);
  432. }
  433.  
  434.